// stores/modules/membership.js
import { defineStore } from 'pinia'
import api from '@/api/modules'

import { message } from '@/utils'

export const useMembershipStore = defineStore('membership', {
  state: () => ({
    // 会员信息
    membershipInfo: null,
    // 会员等级列表
    membershipLevels: [],
    // 订阅订单
    currentOrder: null,
    // 加载状态
    isLoading: false
  }),

  getters: {
    // 是否是VIP
    isVip: (state) => Boolean(state.membershipInfo?.isVip),
    // 当前等级
    currentLevel: (state) => state.membershipInfo?.levelId,
    // 剩余聊天次数
    remainingChatCount: (state) => state.membershipInfo?.remainingChatCount || 0,
    // 剩余切换次数
    remainingSwitchCount: (state) => state.membershipInfo?.remainingSwitchCount || 0,
    // 每日token限额
    dailyTokenLimit: (state) => state.membershipInfo?.dailyTokenLimit || 0,
    // 到期时间
    expireTime: (state) => state.membershipInfo?.expireTime
  },

  actions: {
    // 获取会员信息
    async getMembershipInfo() {
      try {
        console.log('【会员服务】开始获取会员信息');
        this.isLoading = true
        const res = await api.membership.getUserMembership()
        console.log('【会员服务】获取会员信息响应:', JSON.stringify(res));
        
        if (res.code === 200) {
          this.membershipInfo = res.data
          console.log('【会员服务】会员信息更新成功:', JSON.stringify(res.data));
          return res.data
        } else {
          console.warn('【会员服务】获取会员信息失败, 状态码:', res.code, '消息:', res.message);
        }
        return null
      } catch (error) {
        console.error('【会员服务】获取会员信息异常:', error)
        message.error('获取会员信息失败')
        return null
      } finally {
        this.isLoading = false
      }
    },

    // 获取会员等级列表 
    async getMembershipLevels() {
      try {
        console.log('【会员服务】开始获取会员等级列表');
        const res = await api.membership.getAllLevels()
        console.log('【会员服务】获取会员等级列表响应:', JSON.stringify(res));
        
        if (res.code === 200) {
          this.membershipLevels = res.data
          console.log('【会员服务】会员等级列表更新成功, 共', res.data.length, '个等级');
          return res.data
        } else {
          console.warn('【会员服务】获取会员等级列表失败, 状态码:', res.code, '消息:', res.message);
        }
        return []
      } catch (error) {
        console.error('【会员服务】获取会员等级列表异常:', error)
        message.error('获取会员等级列表失败')
        return []
      }
    },

    // 创建订阅订单并前往支付
    async createSubscriptionOrder(params) {
      try {
        console.log('【会员服务】开始创建订阅订单, 参数:', JSON.stringify(params));
        this.isLoading = true
        
        // 确保clientIp参数
        if (!params.clientIp) {
          params.clientIp = '127.0.0.1'
          console.log('【会员服务】使用默认IP地址:127.0.0.1');
        }
        
        // 确保包含用户ID
        if (!params.userId) {
          const userStore = useUserStore();
          params.userId = userStore.userId;
          console.log('【会员服务】自动添加用户ID:', params.userId);
        }
        
        // 确保API路径正确
        const res = await api.membership.createSubscription(params)
        console.log('【会员服务】订阅订单创建响应:', JSON.stringify(res));
        
        if (res.code === 200 && res.data) {
          console.log('【会员服务】订单创建成功, 订单ID:', res.data.orderId);
          this.currentOrder = res.data
          
          // 不在这里处理跳转，而是返回数据让调用方处理
          return res.data
        } else {
          console.error('【会员服务】订单创建失败, 状态码:', res.code, '消息:', res.message);
          message.error(res.message || '创建订单失败')
          return null
        }
      } catch (error) {
        console.error('【会员服务】创建订阅异常:', error)
        message.error('创建订阅失败: ' + (error.message || '未知错误'))
        return null
      } finally {
        this.isLoading = false
      }
    },

    // 获取订单详情
    async getOrderDetail(orderId) {
      try {
        console.log('【会员服务】开始获取订单详情, orderId:', orderId);
        if (!orderId) {
          console.error('【会员服务】订单ID为空');
          message.error('订单ID不能为空')
          return null
        }
        
        const res = await api.membership.getSubscriptionOrder(orderId)
        console.log('【会员服务】获取订单详情响应:', JSON.stringify(res));
        
        if (res.code === 200) {
          this.currentOrder = res.data
          console.log('【会员服务】订单详情更新成功');
          return res.data
        } else {
          console.warn('【会员服务】获取订单详情失败, 状态码:', res.code, '消息:', res.message);
        }
        
        return null
      } catch (error) {
        console.error('【会员服务】获取订单详情异常:', error)
        message.error('获取订单详情失败')
        return null
      }
    },

    // 取消订阅
    async cancelSubscription() {
      try {
        this.isLoading = true
        const res = await api.membership.cancelSubscription()
        if (res.code === 200) {
          message.success('取消订阅成功')
          await this.getMembershipInfo()
          return true
        }
        return false
      } catch (error) {
        console.error('取消订阅失败:', error)
        message.error('取消订阅失败')
        return false
      } finally {
        this.isLoading = false
      }
    },

    // 续费会员
    async renewSubscription(params) {
      try {
        this.isLoading = true
        const res = await api.membership.renewSubscription(params)
        if (res.code === 200) {
          message.success('续订成功')
          await this.getMembershipInfo()
          return res.data
        }
        return null
      } catch (error) {
        console.error('续订失败:', error)
        message.error('续订失败')
        return null
      } finally {
        this.isLoading = false
      }
    },

    // 处理支付成功
    async handlePaymentSuccess(orderId) {
      try {
        console.log('【会员服务】开始处理支付成功回调, orderId:', orderId);
        if (!orderId) {
          console.error('【会员服务】订单ID为空');
          message.error('订单ID不能为空')
          return false
        }
        
        const res = await api.membership.handlePaymentSuccess(orderId)
        console.log('【会员服务】处理支付成功回调响应:', JSON.stringify(res));
        
        if (res.code === 200) {
          console.log('【会员服务】支付回调处理成功, 开始刷新会员信息');
          message.success('会员开通成功')
          await this.getMembershipInfo()
          return true
        } else {
          console.error('【会员服务】支付回调处理失败, 状态码:', res.code, '消息:', res.message);
        }
        
        return false
      } catch (error) {
        console.error('【会员服务】处理支付回调异常:', error)
        message.error('处理支付状态失败')
        return false
      }
    },

    // 刷新每日token
    async refreshDailyTokens() {
      try {
        const res = await api.membership.refreshDailyTokens()
        if (res.code === 200) {
          message.success('刷新成功')
          await this.getMembershipInfo()
          return true
        }
        return false
      } catch (error) {
        console.error('刷新失败:', error)
        message.error('刷新失败')
        return false
      }
    },

    // 检查是否可以聊天
    async checkChatAvailability() {
      try {
        const res = await api.membership.checkChatCount()
        return res.code === 200 && res.data
      } catch (error) {
        console.error('检查聊天次数失败:', error)
        return false  
      }
    },

    // 检查是否可以切换智能体
    async checkSwitchAvailability() {
      try {
        const res = await api.membership.checkSwitchCount()
        return res.code === 200 && res.data
      } catch (error) {
        console.error('检查切换次数失败:', error)
        return false
      }
    },

    // 消费聊天次数
    async consumeChatCount() {
      try {
        const res = await api.membership.consumeChatCount()
        if (res.code === 200) {
          await this.getMembershipInfo()
          return true
        }
        return false
      } catch (error) {
        console.error('消费聊天次数失败:', error)
        return false
      }
    },

    // 消费切换次数
    async consumeSwitchCount() {
      try {
        const res = await api.membership.consumeSwitchCount()
        if (res.code === 200) {
          await this.getMembershipInfo()
          return true
        }
        return false
      } catch (error) {
        console.error('消费切换次数失败:', error)
        return false
      }
    }
  }
})